﻿#define _CRT_SECURE_NO_WARNINGS 1

//指针


//#include<stdio.h>
//
//int main()
//{
//	int a = 25;//变量创建的本质是什么?在内存中开辟一块空间
//	//& -- 取地址操作符
//	//%p -- 专门用来打印地址的--其实是以16进制的形式打印
//	printf("%p\n", &a);
//
//	return 0;
//}



//#include<stdio.h>
//
//int main()
//{
//	int a = 7;
//	int* p = &a;//地址 -- 指针
//	//p是指针变量 -- 用来存放指针(地址)
//  //  * 是在说明pa是指针变量
//  //int 是在说明pa指向的是整型(int)类型的对象。
//	printf("&a = %p\n", &a);
//	printf("p = %p\n", p);
//
//	*p = 3;//解引用操作（间接访问操作）*p等价于a
//	printf("%d\n", *p);
//
//	return 0;
//}

//#include<stdio.h>
//
//int main()
//{
//	int a = 7;
//	int* pa = &a;
//	char ch = 'A';
//	char* pc = &ch;
//
//	printf("%zd\n", sizeof(pa));// 4/8
//	printf("%zd\n", sizeof(int*));// 4/8
//
//	printf("%zd\n", sizeof(pc));// 4/8
//	printf("%zd\n", sizeof(char*));// 4/8
//
//	//指针的大小与类型无关,指针是用来存放地址的,地址需要多大那就需要开多大的空间
//	//32位机器有32根地址总线,需要32个0/1二进制序列,需要32个bit位来存储
//	//64位机器有64根地址总线,需要64个0/1二进制序列,需要4个bit位来存储
//	//32位机器是4个字节,64位是8个字节
//
//
//	return 0;
//}

//指针变量类型的意义 --- 指针的类型决定了，对指针解引⽤的时候有多⼤的权限（⼀次能操作⼏个字节）。

//#include <stdio.h>
//int main()
//{
//	int n = 0x11223344;
//	int* pi = &n;
//	*pi = 0;
//
//	return 0;
//}

//#include <stdio.h>
//int main()
//{
//	int n = 0x11223344;
//	char* pc = (char*)&n;
//	*pc = 0;
//
//	return 0;
//}


//指针 + -整数
//指针的类型决定了指针向前或者向后⾛⼀步有多⼤（距离）。(指针的类型决定了指针的步长)
//#include <stdio.h>
//
//int main()
//{
//
//	int n = 10;
//	char* pc = (char*)&n;
//	int* pi = &n;
//
//	printf("%p\n", &n);
//	printf("%p\n", pc);
//	printf("%p\n", pc + 1);
//	printf("%p\n", pi);
//	printf("%p\n", pi + 1);
//	return 0;
// }


//const 修饰指针

//const修饰变量
//#include <stdio.h>
//int main()
//{
//	int m = 0;
//	m = 20;//m是可以修改的
//	const int n = 0;
//	//n = 20;//n是不能被修改的,但是n还是变量,是常变量
//	return 0;
//}

//#include<stdio.h>
//
//int main()
//{
//	const int n = 7;
//	printf("n = %d\n", n);
//
//	int* p = &n;
//	*p = 3;
//	printf("n = %d\n", n);
//
//	return 0;
//}

//const 修饰指针变量有2种情况
//1. const 放在*的左边:限制的是*p,意思是不能通过p来改变p指向的对象的内容，但是p本身是可以改变的，p可以指向其他对象
//const int* p = &n;
// 
//2. const 放在*的右边:限制的是p，意思是不能修改p本身的值，但是p指向的内容是可以通过p来改变的
//int * const p = &n;
//#include<stdio.h>
//
//int main()
//{
//	int a = 7;
//	int b = 3;
//	const int* pa = &a;
//	int* const pb = &b;
//	printf("pa = %p\n", pa);
//	printf("b = %d\n", b);
//
//	//*pa = 3;//error
//	pa = &b;
//	printf("pa = %p\n", pa);
//
//	*pb = 7;
//	//pb = &a;//error
//	printf("b = %d\n", b);
//
//	return 0;
//}

//指针运算

//指针 + -整数
//#include<stdio.h>
//
//int main()
//{
//	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	//int* p = &arr[0];
//	int* p = arr;//数组名是数组首元素的地址
//	int size = sizeof(arr) / sizeof(int);
//	int i = 0;
//	for (i = 0; i < size; i++)
//	{
//		//printf("arr[%d] = %d\n", i, *p);
//		//p++;//p+i 这⾥就是指针+整数
//		
//		printf("arr[%d] = %d\n", i, *(p + i));//p+i 这⾥就是指针+整数
//	}
//
//	return 0;
//}

//指针 - 指针     运算的前提是两个指针指向了同一块空间
//#include<stdio.h>
//
//int main()
//{
//	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//
//	printf("%d\n", &arr[9] - &arr[0]);
//	printf("%d\n", &arr[0] - &arr[9]);
//	//指针-指针的绝对值是两个指针之间元素的个数
//
//	return 0;
//}

//strlen 是库函数，是专门用来求字符串长度的 -- 计算 \0 之前字符的个数
//模拟实现strlen函数的实现
//#include<stdio.h>
//#include<string.h>
//////方法一
////int my_strlen(char str[])
////{
////	int cnt = 0;
////	while (*str != '\0')
////	{
////		cnt++;
////		str++;
////	}
////	return cnt;
////}
////方法二
//int my_strlen(char* str)
//{
//	char* str1 = str;
//	while (*str != '\0')
//	{
//		str++;
//	}
//	return str - str1;
//}
//
//int main()
//{
//	char str[] = "abcdef";
//	//数组名是数组首元素的地址
//	int ret1 = strlen(str);
//
//	int ret2 = my_strlen(str);
//
//	printf("ret1 = %d\n", ret1);
//	printf("ret2 = %d\n", ret2);
//
//	return 0;
//}

//#include<stdio.h>
//
//int main()
//{
//	int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
//	int* p = arr;
//	int size = sizeof(arr) / sizeof(int);
//	int i = 0;
//	while (p < arr + size)//随着数组下标的增大,数组元素的地址从低到高
//	{
//		printf("arr[%d] = %d\n", i, *p);
//		p++;
//		i++;
//	}
//
//	return 0;
//}

//野指针 --- 指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）

////指针未初始化
//#include<stdio.h>
//
//int main()
//{
//	int* p;//指针变量未初始化
//	*p = 7;//使用了未初始化的指针变量
//	printf("%d\n", *p);
//
//	return 0;
//}

////指针越界访问
//#include<stdio.h>
//
//int main()
//{
//	int arr[10];
//	int* p = &arr[0];
//	int i = 0;
//	for (i = 1; i <= 11; i++)
//	{
//		*p = i;//当指针指向的范围超出数组arr的范围时，p就是野指针
//		p++;
//	}
//
//	return 0;
//}

////指针指向的空间释放
//#include<stdio.h>
//int* test()
//{
//	int n = 0;
//	return &n;
//}
//int main()
//{
//	int* p = test();
//
//	printf("p = %p\n", p);
//
//	return 0;
//}


//字符串逆序
//写一个函数，可以逆序一个字符串的内容。
//#include <stdio.h>
//void reverse_string(char* str)
//{
//
//    int len = strlen(str);
//    char* start = str;
//    char* end = str + len - 1;
//
//    while (start < end)
//    {
//        char tmp = *start;
//        *start = *end;
//        *end = tmp;
//        start++;
//        end--;
//    }
//}
//
//int main() {
//    char str[10001] = { 0 };
//    gets(str);
//
//    reverse_string(str);
//
//    printf("%s\n", str);
//
//    return 0;
//}


//字符串左旋
//实现一个函数，可以左旋字符串中的k个字符。
//例如：
//ABCD左旋一个字符得到BCDA
//ABCD左旋两个字符得到CDAB
#include<stdio.h>
#include<string.h>
void left_reverse(char* str,int k)
{
	int len = strlen(str);
	char* start = str;
	char* end = start + len - 1;
	while (k--)
	{
		while (start != end)
		{
			char tmp = *start;
			*start = *(start + 1);
			*(start + 1) = tmp;

			start++;
		}
	}
}

int main()
{
	char str[] = "ABCD";
	int k = 0;
	while (scanf("%d", &k) != EOF)
	{
		left_reverse(str, k);

		printf("%s\n", str);

	}
	
	return 0;
}


